package com.huawei.esdk.uc.jna;

import java.util.List;

import com.huawei.esdk.uc.jna.Constants.UCServiceRetvCode;
import com.huawei.esdk.uc.jna.callback.AVSessAddedCB;
import com.huawei.esdk.uc.jna.callback.AVSessionClosedCB;
import com.huawei.esdk.uc.jna.callback.AVSessionConnectedCB;
import com.huawei.esdk.uc.jna.callback.ClientSignInNotifyCB;
import com.huawei.esdk.uc.jna.callback.ConfMemberEventCB;
import com.huawei.esdk.uc.jna.callback.PhoneJointEventCB;
import com.huawei.esdk.uc.jna.callback.StatusChangedCB;
import com.huawei.esdk.uc.jna.callback.VideoCallEventCB;
import com.huawei.esdk.uc.jna.mode.CallMember;
import com.huawei.esdk.uc.jna.mode.PhoneJointDevTypeRes;
import com.huawei.esdk.uc.jna.mode.VideoFrameParmas;
import com.huawei.esdk.uc.jna.struct.STCallHistroyData;
import com.huawei.esdk.uc.jna.struct.STConfPartData;
import com.huawei.esdk.uc.jna.struct.STContact;
import com.huawei.esdk.uc.jna.struct.STConvHistroyData;
import com.huawei.esdk.uc.jna.struct.STDeviceListParam;
import com.huawei.esdk.uc.jna.struct.STDeviceParam;
import com.huawei.esdk.uc.jna.struct.STVideoWindow;
import com.sun.jna.Native;
import com.sun.jna.ptr.IntByReference;

/**
 * UCService接口的封装
 * @author lWX169831
 * 
 */
public class UCService
{

    private static final UCServiceLibrary ucServiceLibrary = (UCServiceLibrary) Native
            .loadLibrary("UCService", UCServiceLibrary.class);

    private static UCService instance;

    public static UCService getInstance()
    {
        if (null == instance)
        {
            instance = new UCService();
        }
        return instance;
    }

    private UCService()
    {
    }

    /**
     *初始化
     * 
     *该函数用于初始化数据
     * 
     *@return 0 成功
     *@return 非0 失败（参考错误返回码）
     *@attention 登陆前先初始化
     *@par 无
     **/
    public int UC_SDK_Init()
    {
        return ucServiceLibrary.UC_SDK_Init();
    }

    /**
     *去初始化
     * 
     *该函数用于去初始化数据
     * 
     *@return 0成功
     *@return 非0失败（参考错误返回码）
     *@attention 无
     *@par 无
     **/
    public int UC_SDK_UnInit()
    {
        return ucServiceLibrary.UC_SDK_UnInit();
    }

    /**
     *登录
     * 
     *该函数用于使用账号和密码登陆
     * 
     *@param[in] account 账号
     *@param[in] pwd 密码
     *@param[in] internalurl uri
     *@return 0 成功
     *@return 非0 失败（参考错误返回码）
     *@attention 登陆前先初始化
     *@par 无
     **/
    public int UC_SDK_SignInByPWD(String account, String pwd, String serverUrl,
            String langID)
    {
        return ucServiceLibrary.UC_SDK_SignInByPWD(account, pwd, serverUrl,
                langID);
    }

    /**
     *登出
     * 
     *该函数用于注销登陆
     * 
     *@return 0 成功
     *@return 非0 失败（参考错误返回码）
     *@attention 无
     *@par 无
     **/
    public int UC_SDK_SignOut()
    {
        return ucServiceLibrary.UC_SDK_SignOut();
    }

    /**
     *设置登录回调
     * 
     *该函数用于设置登录回调函数
     * 
     *@param[in] loginEventCB_ 登陆回调函数指针
     *@return 0 成功
     *@return 非0 失败（参考错误返回码）
     *@attention 登陆前必须调用
     *@par 无
     **/
    public int UC_SDK_SetLoginEventCB(ClientSignInNotifyCB loginEventCB)
    {
        return ucServiceLibrary.UC_SDK_SetLoginEventCB(loginEventCB);
    }

    /**
     *设置状态回调
     * 
     *该函数用于设置状态回调函数
     * 
     *@param[in] statusChangedCallBack 状态回调函数指针
     *@return 0 成功
     *@return 非0 失败（参考错误返回码）
     *@attention 登陆前必须调用
     *@par 无
     **/
    public int UC_SDK_SetStatusChangedCB(StatusChangedCB statusChangedCallBack)
    {
        return ucServiceLibrary
                .UC_SDK_SetStatusChangedCB(statusChangedCallBack);
    }

    /**
     *订阅某个联系人状态
     * 
     *该函数用于订阅某个联系人状态
     * 
     *@param[in] _Account 联系人账户
     *@return 0 成功
     *@return 非 失败（参考错误返回码）
     *@attention 登录成功后调用
     *@par 无
     **/
    public int UC_SDK_SubscribeStatus(String account)
    {
        return ucServiceLibrary.UC_SDK_SubscribeStatus(account);
    }

    /**
     *取消订阅某个联系人状态
     * 
     *该函数用于取消订阅某个联系人状态
     * 
     *@param[in] _Account 联系人账户
     *@return 0 成功
     *@return 非 失败（参考错误返回码）
     *@attention 登录成功后调用
     *@par 无
     **/
    public int UC_SDK_UnSubscribeStatus(String account)
    {
        return ucServiceLibrary.UC_SDK_UnSubscribeStatus(account);
    }

    /**
     *获取联系人状态
     * 
     *该函数用于获取联系人个人状态
     * 
     *@param[in] _AccountType联系人账户类型
     *@param[in] _Account 联系人账户
     *@param[out] _Status 状态
     *@return 0 成功
     *@return 非0 失败（参考错误返回码）
     *@attention 登录成功后调用
     *@par 无
     **/
    public int UC_SDK_GetContactStatus(int accountType, String account)
    {
        IntByReference status = new IntByReference(-1);
        ucServiceLibrary.UC_SDK_GetContactStatus(accountType, account, status);
        return status.getValue();
    }

    /**
     *发布状态
     * 
     *该函数用于发布个人状态
     * 
     *@param[in] _Status 状态
     *@param[in] _Desc 状态描述
     *@return 0 成功
     *@return 非0 失败（参考错误返回码）
     *@attention 登陆后立即调用
     *@par 无
     **/
    public int UC_SDK_PubSelfStatus(int dtatus, String desc)
    {
        return ucServiceLibrary.UC_SDK_PubSelfStatus(dtatus, desc);
    }

    /**
     *获取联系人信息
     * 
     *该函数用于获取联系人信息
     * 
     *@param[in] _Account 联系人账户
     *@param[out] _pContactInfo 联系人的信息
     *@return 非null 成功
     *@return null 失败（参考错误返回码）
     *@attention 登录成功后调用
     *@par 无
     **/
    public STContact UC_SDK_GetContactInfo(String account)
    {
        STContact contact = new STContact();
        if (ucServiceLibrary.UC_SDK_GetContactInfo(account, contact
                .getPointer()) == 0)
        {
            contact.read();
            return contact;
        }
        return null;
    }

    // ******************* 呼叫部分 ******************

    public int UC_SDK_SetCallEventCallBack(
            AVSessionClosedCB aVSessionClosedCallBack,
            AVSessionConnectedCB aVSessionConnectedCallBack,
            AVSessAddedCB aVSessAddedCallBack)
    {

        return ucServiceLibrary.UC_SDK_SetCallEventCallBack(
                aVSessionClosedCallBack, aVSessionConnectedCallBack,
                aVSessAddedCallBack);
    }

    /**
     *设置视频呼叫事件回调
     * 
     *该函数用于设置视频呼叫事件回调函数
     * 
     *@param[in] callEventCallBack 视频通话事件回调函数指针
     *@return 0 成功
     *@return 非0 失败（参考错误返回码）
     *@attention 登陆后立即调用
     *@par 无
     **/
    public int UC_SDK_SetVideoCallEventCallBack(
            VideoCallEventCB callEventCallBack)
    {
        return ucServiceLibrary
                .UC_SDK_SetVideoCallEventCallBack(callEventCallBack);
    }

    /**
     *设置会议中事件回调
     * 
     *该函数用于设置会议中成员状态变化事件回调
     * 
     *@param[in] confMemEventCallBack
     *@return 0 成功
     *@return 非0 失败（参考错误返回码）
     *@attention 送到连接成功函数返回后调用
     *@par 无
     **/
    public int UC_SDK_SetConfMemEventCallBack(
            ConfMemberEventCB confMemEventCallBack)
    {
        return ucServiceLibrary
                .UC_SDK_SetConfMemEventCallBack(confMemEventCallBack);
    }

    /**
     * 发起语音呼叫
     * @param members
     * @return
     */
    public int UC_SDK_MakeCall(List<CallMember> members)
    {
        for (CallMember callMember : members)
        {
            ucServiceLibrary.UC_SDK_AddCallMember(callMember.getMemberType(),
                    callMember.getMember());
        }
        return ucServiceLibrary.UC_SDK_MakeCall();
    }

    /**
     * 发起视频呼叫（视频呼叫只能是单人）
     * @param member
     * @return
     */
    public int UC_SDK_MakeVideoCall(CallMember member)
    {
        ucServiceLibrary.UC_SDK_AddCallMember(member.getMemberType(), member
                .getMember());

        VideoFrameParmas parmas = member.getVideoFrameParmas();
        STVideoWindow localWindow = parmas.getLocalWindow();
        STVideoWindow remoteWindow = parmas.getRemoteWindow();

        return ucServiceLibrary.UC_SDK_MakeVideoCall(localWindow.hWnd,
                localWindow.left, localWindow.top, localWindow.width,
                localWindow.height, remoteWindow.hWnd, remoteWindow.left,
                remoteWindow.top, remoteWindow.width, remoteWindow.height);
    }

    /**
     * 升级视频呼叫（两人之间的语音通话才能升级）
     * @param parmas
     * @return
     */
    public int UC_SDK_MakeVideoCall(VideoFrameParmas parmas)
    {
        STVideoWindow localWindow = parmas.getLocalWindow();
        STVideoWindow remoteWindow = parmas.getRemoteWindow();
        return ucServiceLibrary.UC_SDK_MakeVideoCall(localWindow.hWnd,
                localWindow.left, localWindow.top, localWindow.width,
                localWindow.height, remoteWindow.hWnd, remoteWindow.left,
                remoteWindow.top, remoteWindow.width, remoteWindow.height);
    }

    /**
     *语音会议中邀请成员
     * 
     *该函数用于语音会议中邀请成员
     * 
     *@param[in] memberType_ 账户类型，参考枚举类型EM_MemberType
     *@param[in] pAccount 账号
     *@return 0 成功
     *@return 非0 失败（参考错误返回码）
     *@attention 暂无
     *@par 无
     **/
    public int UC_SDK_InviteMemberInCall(int memberType_, String pAccount)
    {
        return ucServiceLibrary
                .UC_SDK_InviteMemberInCall(memberType_, pAccount);
    }

    /**
     *语音会议中删除成员
     * 
     *该函数用于语音会议中删除成员
     * 
     *@param[in] memberType 账号类型，参考枚举类型 AccountType
     *@param[in] pAccount 账号
     *@return 0 成功
     *@return 非0 失败（参考错误返回码）
     *@attention 暂无
     *@par 无
     **/
    public int UC_SDK_DeleteMemberInCall(int memberType, String pAccount)
    {
        return ucServiceLibrary.UC_SDK_DeleteMemberInCall(memberType, pAccount);
    }

    /**
     * 挂断电话
     * @return
     */
    public int UC_SDK_HangupCall()
    {
        return ucServiceLibrary.UC_SDK_HangupCall();
    }

    /**
     *结束视频通话
     * 
     *该函数用于结束视频通话，保留语音通话
     * 
     *@return 0 成功
     *@return 非0 失败（参考错误返回码）
     *@attention 主动挂断视频通话时调用（）
     *@par 无
     **/
    public int UC_SDK_HangupVideoCall()
    {
        return ucServiceLibrary.UC_SDK_HangupVideoCall();
    }

    /**
     *接听呼叫
     * 
     *该函数用于接听呼叫
     * 
     *@return 0 成功
     *@return 非0 失败（参考错误返回码）
     *@attention 无
     *@par 无
     **/
    public int UC_SDK_AcceptCall()
    {
        return ucServiceLibrary.UC_SDK_AcceptCall();
    }

    /**
     *接听视频呼叫
     * 
     *该函数用于接听视频呼叫
     * 
     *@return 0 成功
     *@return 非0 失败（参考错误返回码）
     *@attention 无
     *@par 无
     **/
    public int UC_SDK_AcceptVideoCall(VideoFrameParmas parmas)
    {
        STVideoWindow localWindow = parmas.getLocalWindow();
        STVideoWindow remoteWindow = parmas.getRemoteWindow();
        return ucServiceLibrary.UC_SDK_AcceptVideoCall(localWindow.hWnd,
                localWindow.left, localWindow.top, localWindow.width,
                localWindow.height, remoteWindow.hWnd, remoteWindow.left,
                remoteWindow.top, remoteWindow.width, remoteWindow.height);
    }

    /**
     *拒绝呼叫
     * 
     *该函数用于拒绝呼叫
     * 
     *@return 0 成功
     *@return 非0 失败（参考错误返回码）
     *@attention 无
     *@par 无
     **/
    public int UC_SDK_RejectCall()
    {
        return ucServiceLibrary.UC_SDK_RejectCall();
    }

    /**
     *拒绝视频呼叫
     * 
     *该函数用于拒绝视频呼叫
     * 
     *@return 0 成功
     *@return 非0 失败（参考错误返回码）
     *@attention 无
     *@par 无
     **/
    public int UC_SDK_RejectVideoCall()
    {
        return ucServiceLibrary.UC_SDK_RejectVideoCall();
    }

    /**
     *查询呼叫成员
     * 
     *该函数用于查询呼叫成员的账户
     * 
     *@param[in] phoneNum phone number
     *@param[out] _UCAcc UC成员账户名称
     *@return 非null 成功
     *@return null 失败
     *@attention 增加账户时，先查询此用户是否存在对应的UC账户
     *@par 无
     **/
    public String UC_SDK_GetUCAccount(String phoneNum)
    {
        byte[] UCAcc = new byte[Constants.STRING_LENGTH];
        if (0 == ucServiceLibrary.UC_SDK_GetUCAccount(phoneNum, UCAcc))
        {
            return new String(UCAcc);
        }
        return null;
    }

    /**
     *通话保持
     * 
     *该函数用于通话保持
     * 
     *@return 0 成功
     *@return 非0 失败（参考错误返回码）
     *@attention 无
     *@par 无
     **/
    public int UC_SDK_HoldCall()
    {
        return ucServiceLibrary.UC_SDK_HoldCall();
    }

    /**
     *通话恢复
     * 
     *该函数用于通话恢复
     * 
     *@return 0 成功
     *@return 非0 失败（参考错误返回码）
     *@attention 无
     *@par 无
     **/
    public int UC_SDK_ResumeCall()
    {
        return ucServiceLibrary.UC_SDK_ResumeCall();
    }

    /**
     *二次拨号
     * 
     *该函数用于二次拨号接口，支持0123456789*#等12个字符
     * 
     *@param[in] tones 拨号字符串
     *@return 0 成功
     *@return 非0 失败（参考错误返回码）
     *@attention 无
     *@par 无
     **/
    public int UC_SDK_SendDTMF(char tone)
    {
        return ucServiceLibrary.UC_SDK_SendDTMF(tone);
    }

    /**
     *呼叫前转
     * 
     *该函数用于呼叫前转
     * 
     *@param[in] iMemberType 成员类型
     *@param[in] pMember UC账号或者ipphone
     *@return 0 成功
     *@return 非0 失败（参考错误返回码）
     *@attention 无
     *@par 无
     **/
    public int UC_SDK_ForwardCall(int iMemberType, String pMember)
    {
        return ucServiceLibrary.UC_SDK_ForwardCall(iMemberType, pMember);
    }

    /**
     *麦克风静音
     * 
     *该函数用于麦克风静音
     * 
     *@return 0 成功
     *@return 非0 失败（参考错误返回码）
     *@attention 无
     *@par 无
     **/
    public int UC_SDK_MuteMic()
    {
        return ucServiceLibrary.UC_SDK_MuteMic();
    }

    /**
     *麦克风取消静音
     * 
     *该函数用于麦克风取消静音
     * 
     *@return 0 成功
     *@return 非0 失败（参考错误返回码）
     *@attention 无
     *@par 无
     **/
    public int UC_SDK_UnMuteMic()
    {
        return ucServiceLibrary.UC_SDK_UnMuteMic();
    }

    /**
     *获取麦克风音量
     * 
     *该函数用于获取麦克风音量
     * 
     *@param[out] level 麦克风音量
     *@return 非-1 麦克风音量
     *@return -1 失败（参考错误返回码）
     *@attention 无
     *@par 无
     **/
    public int UC_SDK_GetMicLevel()
    {
        IntByReference level = new IntByReference(-1);
        ucServiceLibrary.UC_SDK_GetMicLevel(level);
        return level.getValue();
    }

    /**
     *设置麦克风音量
     * 
     *该函数用于设置麦克风音量
     * 
     *@param[in] level 麦克风音量
     *@return 0 成功
     *@return 非0 失败（参考错误返回码）
     *@attention 无
     *@par 无
     **/
    public int UC_SDK_SetMicLevel(int level)
    {
        return ucServiceLibrary.UC_SDK_SetMicLevel(level);
    }

    /**
     *扬声器静音
     * 
     *该函数用于扬声器静音
     * 
     *@return 0 成功
     *@return 非0 失败（参考错误返回码）
     *@attention 无
     *@par 无
     **/
    public int UC_SDK_MuteSpker()
    {
        return ucServiceLibrary.UC_SDK_MuteSpker();
    }

    /**
     *扬声器取消静音
     * 
     *该函数用于扬声器取消静音
     * 
     *@return 0 成功
     *@return 非0 失败（参考错误返回码）
     *@attention 无
     *@par 无
     **/
    public int UC_SDK_UnMuteSpker()
    {
        return ucServiceLibrary.UC_SDK_UnMuteSpker();
    }

    /**
     *获取扬声器音量
     * 
     *该函数用于获取麦克风音量
     * 
     *@param[out] level 扬声器音量
     *@return 0 成功
     *@return 非0 失败（参考错误返回码）
     *@attention 无
     *@par 无
     **/
    public int UC_SDK_GetSpkerLevel()
    {
        IntByReference level = new IntByReference(-1);
        ucServiceLibrary.UC_SDK_GetSpkerLevel(level);
        return level.getValue();
    }

    /**
     *设置扬声器音量
     * 
     *该函数用于设置扬声器音量
     * 
     *@param[in] level 扬声器音量
     *@return 0 成功
     *@return 非0 失败（参考错误返回码）
     *@attention 无
     *@par 无
     **/
    public int UC_SDK_SetSpkerLevel(int level)
    {
        return ucServiceLibrary.UC_SDK_SetSpkerLevel(level);
    }

    /**
     *获取麦克风设备列表
     * 
     *该函数用于获取麦克风设备列表
     * 
     *@param[in] _fromIndex 开始索引
     *@param[in] _toIndex 结束索引
     *@param[in] _size 结构体大小
     *@param[out] devList 设备列表
     *@return 非null 成功
     *@return null 失败（参考错误返回码）
     *@attention [_fromIndex, _toIndex], 包含_fromIndex, _toIndex
     *@par 无
     **/
    public STDeviceListParam UC_SDK_GetMicDevList(int fromIndex, int toIndex)
    {
        int size = toIndex - fromIndex + 1;
        STDeviceListParam devList = new STDeviceListParam(size);
        int ret = ucServiceLibrary.UC_SDK_GetMicDevList(fromIndex, toIndex,
                devList.size(), devList.getPointer());
        if (UCServiceRetvCode.UC_SDK_Success == ret)
        {
            devList.read();
            return devList;
        }
        return null;
    }

    /**
     *获取扬声器设备列表
     * 
     *该函数用于获取扬声器设备列表
     * 
     *@param[in] _fromIndex 开始索引
     *@param[in] _toIndex 结束索引
     *@param[in] _size 结构体大小
     *@param[out] devList 设备列表
     *@return 非null 成功
     *@return null 失败（参考错误返回码）
     *@attention [_fromIndex, _toIndex], 包含_fromIndex, _toIndex
     *@par 无
     **/
    public STDeviceListParam UC_SDK_GetSpeakerDevList(int fromIndex, int toIndex)
    {
        int size = toIndex - fromIndex + 1;
        STDeviceListParam devList = new STDeviceListParam(size);
        int ret = ucServiceLibrary.UC_SDK_GetSpeakerDevList(fromIndex, toIndex,
                devList.size(), devList.getPointer());
        if (UCServiceRetvCode.UC_SDK_Success == ret)
        {
            devList.read();
            return devList;
        }
        return null;
    }

    /**
     *获取视频设备列表
     * 
     *该函数用于获取视频设备列表
     * 
     *@param[in] _fromIndex 开始索引
     *@param[in] _toIndex 结束索引
     *@param[in] _size 结构体大小
     *@param[out] devList 设备列表
     *@return 非null 成功
     *@return null 失败（参考错误返回码）
     *@attention [_fromIndex, _toIndex], 包含_fromIndex, _toIndex
     *@par 无
     **/
    public STDeviceListParam UC_SDK_GetVideoDevList(int fromIndex, int toIndex)
    {
        int size = toIndex - fromIndex + 1;
        STDeviceListParam devList = new STDeviceListParam(size);
        int ret = ucServiceLibrary.UC_SDK_GetVideoDevList(fromIndex, toIndex,
                devList.size(), devList.getPointer());
        if (Constants.UCServiceRetvCode.UC_SDK_Success == ret)
        {
            devList.read();
            return devList;
        }
        return null;
    }

    /**
     *获取当前麦克风设备
     * 
     *该函数用于获取当前麦克风设备
     * 
     *@param[out] device 当前麦克风设备
     *@return 0 成功
     *@return 非0 失败（参考错误返回码）
     *@attention 暂无
     *@par 无
     **/
    public STDeviceParam UC_SDK_GetCurrentMicDev()
    {
        STDeviceParam param = new STDeviceParam();
        if (ucServiceLibrary.UC_SDK_GetCurrentMicDev(param.getPointer()) == 0)
        {
            param.read();
            return param;
        }
        return null;
    }

    /**
     *获取当前扬声器设备
     * 
     *该函数用于获取当前扬声器设备
     * 
     *@param[out] device 当前扬声器设备
     *@return 0 成功
     *@return 非0 失败（参考错误返回码）
     *@attention 暂无
     *@par 无
     **/
    public STDeviceParam UC_SDK_GetCurrentSpeakerDev()
    {
        STDeviceParam param = new STDeviceParam();
        if (ucServiceLibrary.UC_SDK_GetCurrentSpeakerDev(param.getPointer()) == 0)
        {
            param.read();
            return param;
        }
        return null;
    }

    /**
     *获取当前视频设备
     * 
     *该函数用于获取当前视频设备
     * 
     *@param[out] device 当前视频设备
     *@return 0 成功
     *@return 非0 失败（参考错误返回码）
     *@attention 暂无
     *@par 无
     **/
    public STDeviceParam UC_SDK_GetCurrentVideoDev()
    {
        STDeviceParam param = new STDeviceParam();
        if (ucServiceLibrary.UC_SDK_GetCurrentVideoDev(param.getPointer()) == 0)
        {
            param.read();
            return param;
        }
        return null;
    }

    /**
     *设置当前麦克风设备
     * 
     *该函数用于设置当前麦克风设备
     * 
     *@param[in] index 设备索引
     *@return 0 成功
     *@return 非0 失败（参考错误返回码）
     *@attention 暂无
     *@par 无
     **/
    public int UC_SDK_SetCurrentMicDev(int index)
    {
        return ucServiceLibrary.UC_SDK_SetCurrentMicDev(index);
    }

    /**
     *设置当前扬声器设备
     * 
     *该函数用于设置当前扬声器设备
     * 
     *@param[in] index 设备索引
     *@return 0 成功
     *@return 非0 失败（参考错误返回码）
     *@attention 暂无
     *@par 无
     **/
    public int UC_SDK_SetCurrentSpeakerDev(int index)
    {
        return ucServiceLibrary.UC_SDK_SetCurrentSpeakerDev(index);
    }

    /**
     *设置当前视频设备
     * 
     *该函数用于设置当前视频设备
     * 
     *@param[in] index 设备索引
     *@return 0 成功
     *@return 非0 失败（参考错误返回码）
     *@attention 暂无
     *@par 无
     **/
    public int UC_SDK_SetCurrentVideoDev(int index)
    {
        return ucServiceLibrary.UC_SDK_SetCurrentVideoDev(index);
    }

    /**
     *获取话机联动设备类型
     * 
     *该函数用于获取话机联动设备类型
     * 
     *@param[out] _iDevType 联动设备类型
     *@return 0为pc,1为iphone
     *@attention 无
     *@par 无
     **/
    public PhoneJointDevTypeRes UC_SDK_GetPhoneJointDevType()
    {
        PhoneJointDevTypeRes phoneJointDevTypeRes = new PhoneJointDevTypeRes(
                -1, 0);
        IntByReference intByReference = new IntByReference(-1);
        int iRet = ucServiceLibrary.UC_SDK_GetPhoneJointDevType(intByReference);
        int devType = 0;
        if (0 == iRet)
        {
            devType = intByReference.getValue();
        }
        phoneJointDevTypeRes.setRetCode(iRet);
        phoneJointDevTypeRes.setDevType(devType);
        return phoneJointDevTypeRes;
    }

    /**
     *设置话机联动设备类型
     * 
     *该函数用于设置话机联动设备类型
     * 
     *@param[in] _iDevType 联动设备类型
     *@return 0 成功
     *@return 非0 失败（参考错误返回码）
     *@attention 无
     *@par 无
     **/
    public int UC_SDK_SetPhoneJointDevType(int iDevType)
    {
        int iRet = ucServiceLibrary.UC_SDK_SetPhoneJointDevType(iDevType);
        return iRet;
    }

    /**
     *设置话机联动事件回调
     * 
     *该函数用于设置话机联动事件回调函数
     * 
     *@param[in] pjEventCallBack 话机联动事件回调函数指针
     *@return 0 成功
     *@return 非0 失败（参考错误返回码）
     *@attention 登陆后立即调用
     *@par 无
     **/
    public int UC_SDK_SetPhoneJointEventCallBack(
            PhoneJointEventCB pjEventCallBack)
    {
        int iRet = ucServiceLibrary
                .UC_SDK_SetPhoneJointEventCallBack(pjEventCallBack);
        return iRet;
    }

    /**
     *查询单人呼叫历史记录
     * 
     *该函数查询单人呼叫历史记录
     * 
     *@param[in] _callType
     *@param[in] _fromIndex
     *@param[in] _toIndex
     *@param[out] _result
     *@param[out] _size 指针_result所指内存的大小
     *@return 非null 成功
     *@return null 失败（参考错误返回码）
     *@attention 送到连接成功函数返回后调用
     *@par 无
     **/
    public STCallHistroyData UC_SDK_QueryCallHistory(int callType,
            int fromIndex, int toIndex)
    {
        int size = toIndex - fromIndex + 1;
        STCallHistroyData callHistroyData = new STCallHistroyData(size);
        int ret = ucServiceLibrary.UC_SDK_QueryCallHistory(callType, fromIndex,
                toIndex, callHistroyData.getPointer(), callHistroyData.size());
        if (UCServiceRetvCode.UC_SDK_Success == ret)
        {
            callHistroyData.read();
            return callHistroyData;
        }
        return null;
    }

    /**
     *清除单人呼叫历史记录
     * 
     *该函数清除单人呼叫历史记录
     * 
     *@param[in] _callType
     *@return 0 成功
     *@return 非0 失败（参考错误返回码）
     *@attention 送到连接成功函数返回后调用
     *@par 无
     **/
    public int UC_SDK_ClearCallHistroy(int callType)
    {
        return ucServiceLibrary.UC_SDK_ClearCallHistroy(callType);
    }

    /**
     *插入呼叫历史记录
     * 
     *该函数用于插入呼叫历史记录
     * 
     *@param[in] _callType
     *@param[in] _account
     *@param[in] _name
     *@param[in] _duration
     *@return 0 成功
     *@return 非0 失败（参考错误返回码）
     *@attention 送到连接成功函数返回后调用
     *@par 无
     **/
    public int UC_SDK_InsertCallHistory(int callType, String account,
            String name, int duration)
    {
        return ucServiceLibrary.UC_SDK_InsertCallHistory(callType, account,
                name, duration);
    }

    /**
     *删除一条呼叫记录
     * 
     *该函数用于删除一条呼叫记录
     * 
     *@param[in] iCallType 删除记录类型
     *@param[in] iIndex 删除记录索引
     *@return 0 成功
     *@return 非0 失败（参考错误返回码）
     *@attention 无
     *@par 无
     **/
    public int UC_SDK_DeleteCallHistory(int iRcdID)
    {
        return ucServiceLibrary.UC_SDK_DeleteCallHistory(iRcdID);
    }

    /**
     *查询会议历史记录
     * 
     *该函数会议历史记录
     * 
     *@param[in] _fromIndex 开始序列
     *@param[in] _toIndex 结束序列
     *@param[out] _result 返回的会议历史记录结果
     *@param[out] _size 指针_result所指内存的大小
     *@return 非null 成功
     *@return null 失败（参考错误返回码）
     *@attention 无
     *@par 无
     **/
    public STConvHistroyData UC_SDK_QueryConvHistory(int fromIndex, int toIndex)
    {
        int size = toIndex - fromIndex + 1;
        STConvHistroyData convHistroyData = new STConvHistroyData(size);
        int ret = ucServiceLibrary.UC_SDK_QueryConvHistory(fromIndex, toIndex,
                convHistroyData.getPointer(), convHistroyData.size());
        if (UCServiceRetvCode.UC_SDK_Success == ret)
        {
            convHistroyData.read();
            return convHistroyData;
        }
        return null;
    }

    /**
     *查询一条会议历史记录的参与者
     * 
     *该函数用于查询一条会议历史记录的参与者
     * 
     *@param[in] _convID 会议历史记录ID，由UC_SDK_QueryConvHistory接口查询出来
     *@param[in] _fromIndex 开始序列
     *@param[in] _toIndex 结束序列
     *@param[out] _result 返回的结果存放地址
     *@param[out] _size 指针_result所指内存的大小
     *@return 0 成功
     *@return 非0 失败（参考错误返回码）
     *@attention 
     *            调用UC_SDK_QueryConvHistory后，会获取到_convID，然后可以调用UC_SDK_QueryHisConvPartByID
     *@par 无
     **/
    public STConfPartData UC_SDK_QueryHisConvPartByID(String convID,
            int fromIndex, int toIndex)
    {
        int size = toIndex - fromIndex + 1;
        STConfPartData confPartData = new STConfPartData(size);
        int ret = ucServiceLibrary.UC_SDK_QueryHisConvPartByID(convID,
                fromIndex, toIndex, confPartData.getPointer(), confPartData
                        .size());
        if (UCServiceRetvCode.UC_SDK_Success == ret)
        {
            confPartData.read();
            return confPartData;
        }
        return null;
    }

    /**
     *插入会议历史记录
     * 
     *该函数用于插入会议历史记录
     * 
     *@param[in] _leaderAccount 主持人账户
     *@param[in] _leaderName 主持人姓名
     *@param[in] _duration 会议持续时间
     *@param[out] _historyID 会议历史记录ID
     *@return 非null 成功
     *@return null 失败（参考错误返回码）
     *@attention 无
     *@par 无
     **/
    public String UC_SDK_InsertConvHistory(String leaderAccount,
            String leaderName, int duration)
    {
        byte[] historyID = new byte[Constants.STRING_LENGTH];

        if (0 == ucServiceLibrary.UC_SDK_InsertConvHistory(leaderAccount,
                leaderName, duration, historyID))
        {
            return new String(historyID);
        }
        return null;
    }

    /**
     *插入会议历史记录的与会人
     * 
     *该函数用于插入会议历史记录的与会人
     * 
     *@param[in] _partAccount 与会者账户
     *@param[in] _partName 与会者姓名
     *@param[in] _historyConvID 会议历史记录ID，调用UC_SDK_InsertConvHistory生成
     *@return 0 成功
     *@return 非0 失败（参考错误返回码）
     *@attention 调用UC_SDK_InsertConvHistory后，获取到_historyConvID，
     *            然后可以调用UC_SDK_InsertConvHistoryPart插入成员
     *@par 无
     **/
    public int UC_SDK_InsertConvHistoryPart(String historyConvID,
            String partAccount, String partName)
    {
        return ucServiceLibrary.UC_SDK_InsertConvHistoryPart(historyConvID,
                partAccount, partName);
    }

    /**
     *删除一条会议记录
     * 
     *该函数用于删除一条会议记录
     * 
     *@param[in] _pConvID 删除会议历史记录的ID
     *@return 0 成功
     *@return 非0 失败（参考错误返回码）
     *@attention 无
     *@par 无
     **/
    public int UC_SDK_DeleteConvHistory(String pConvID)
    {
        return ucServiceLibrary.UC_SDK_DeleteConvHistory(pConvID);
    }

    /**
     *包括语音会议中断开某成员的语音，语音会议中重新呼叫某成员，语音会议中对某成员静音，对某成员取消静音4种。
     * 
     *该函数用于包括语音会议中断开某成员的语音，语音会议中重新呼叫某成员，语音会议中对某成员静音，对某成员取消静音4种。
     * 
     *@param[in] operateType 操作类型，参考枚举类型EM_ConvnerOperateType
     *@param[in] memberType_ 账号类型，参考枚举类型AccountType
     *@param[in] pAccount UC账号
     *@return 0 成功
     *@return 非0 失败（参考错误返回码）
     *@attention 暂无
     *@par 无
     **/
    public int UC_SDK_ModifyMemberStatusInCall(int operateType, int memberType,
            String pAccount)
    {
        return ucServiceLibrary.UC_SDK_ModifyMemberStatusInCall(operateType,
                memberType, pAccount);
    }

    /**
     *单点登录个人管理平台或者预约会议页面
     * 
     *该函数用于单点登录个人管理平台或者预约会议页面
     * 
     *@param[in] _type 打开页面的类型，参考枚举类型EM_PortalType
     *@return 0 成功
     *@return 非0 失败（参考错误返回码）
     *@attention 登陆后立即调用
     *@par 无
     **/
    public int UC_SDK_OpenPortal(int pageType)
    {
        int iRet = Constants.UCServiceRetvCode.UC_SDK_Failed;
        if (0 != pageType && 1 != pageType)
        {
            iRet = Constants.UCServiceRetvCode.UC_SDK_InvalidPara;
        }
        else
        {
            iRet = ucServiceLibrary.UC_SDK_OpenPortal(pageType);
        }
        return iRet;
    }
}
